package com.sg.service.biz.component.nb;

import cn.hutool.core.bean.BeanUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.dto.biz.component.req.*;
import com.sg.dto.biz.component.res.*;
import com.sg.service.biz.component.TemplateEngineService;
import com.wicket.okrcomponent.common.annotations.BanAuto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Random;

/**
 * @author ： 手工接入方法
 * @version 1.0
 * @since 2022/5/28 15:32
 */
@Service
@BanAuto
public class NbTemplateEngine {

    @Autowired
    TemplateEngineService templateEngineService;

    /**
     * code:generateSemanticInstance
     * name:生成语义实例
     * desc:undefined
     **/
    @BanAuto
    @Trace(operationName = "生成语义实例")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateSemanticInstanceResDto generateSemanticInstance(GenerateSemanticInstanceReqDto reqDto) {
        GenerateSemanticInstanceResDto retData = new GenerateSemanticInstanceResDto();
        SimpleDateFormat ft = new SimpleDateFormat("yyyyMMddHH:mm:ss");
        String timeStr = ft.format(CommonFunctionHelper.getCurrentTime());
        retData.setTemplateContent(reqDto.getSentenceContentParam() + timeStr);
        return retData;
    }

    /**
     * code:receptionService
     * name:M2-获取接收字段
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:21 PM
     **/
    @Trace(operationName = "M2-获取接收字段")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainReceiveFieldsRespDto obtainReceiveFields(ObtainReceiveFieldsReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ObtainReceiveFieldsRespDto.class);
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（目标周期名称）
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:27 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（目标周期名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateTargetCycleNameRespDto generateTargetCycleName(GenerateTargetCycleNameReqDto reqDto) {
        //{cycleStandardName}{targetContentName}
        Boolean bRetFlag = false;
        String retConent = "";
        GenerateTargetCycleNameRespDto retData = new GenerateTargetCycleNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_TARGET_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, "---");
                retConent = retConent.replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（周期名称）
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:33 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（周期名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateTotalCycleNameRespDto generateTotalCycleName(GenerateTotalCycleNameReqDto reqDto) {
        //{cycleStartName}-{cycleEndName}
        Boolean bRetFlag = false;
        String retConent = "";
        GenerateTotalCycleNameRespDto retData = new GenerateTotalCycleNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_TOTAL_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStartName = "\\{cycleStartName}";
            String cycleEndName = "\\{cycleEndName}";
            if (reqDto.getCycleStartName() != null && reqDto.getCycleEndName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartName, reqDto.getCycleStartName());
                retConent = retConent.replaceAll(cycleEndName, reqDto.getCycleEndName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartName, "---");
                retConent = retConent.replaceAll(cycleEndName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（不规则周期名称）
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:39 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（不规则周期名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateIrregularCycleNameRespDto generateIrregularCycleName(GenerateIrregularCycleNameReqDto reqDto) {
        //{cycleStartTime} 至 {cycleEndTime}
        Boolean bRetFlag = false;
        String retConent = "";
        GenerateIrregularCycleNameRespDto retData = new GenerateIrregularCycleNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_IRREGULAR_CYCLE_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStartTime = "\\{cycleStartTime}";
            String cycleEndTime = "\\{cycleEndTime}";
            if (reqDto.getCycleStartTime() != null && reqDto.getCycleEndTime() != null) {
                bRetFlag = true;
                String start = CommonFunctionHelper.date2specStr(reqDto.getCycleStartTime());
                start = start.substring(2, start.length());

                String end = CommonFunctionHelper.date2specStr(reqDto.getCycleEndTime());
                end = end.substring(2, end.length());
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartTime, start);
                retConent = retConent.replaceAll(cycleEndTime, end);
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartTime, "---");
                retConent = retConent.replaceAll(cycleEndTime, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（不规则周期类型名称）
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:45 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（不规则周期类型名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateIrregularCycleTypeNameRespDto createIrregularCycleTypeName(CreateIrregularCycleTypeNameReqDto reqDto) {
        //{acount}个{cycleTypeName}
        Boolean bRetFlag = false;
        String retConent = "";
        CreateIrregularCycleTypeNameRespDto retData = new CreateIrregularCycleTypeNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_TYPE_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeName = "\\{cycleTypeName}";
            if (reqDto.getAcount() != null && reqDto.getCycleTypeName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeName, reqDto.getCycleTypeName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = retConent.replaceAll(cycleTypeName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（不规则周期类型标识）
     * desc:undefined
     * gen by moon at 10/27/2022, 6:28:51 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（不规则周期类型标识）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateCycleTypeCodeRespDto createCycleTypeCode(CreateCycleTypeCodeReqDto reqDto) {
        //{acount}{cycleTypeCode}
        Boolean bRetFlag = false;
        String retConent = "";
        CreateCycleTypeCodeRespDto retData = new CreateCycleTypeCodeRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_CYCLE_TYPE_CODE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String acount = "\\{acount}";
            String cycleTypeCode = "\\{cycleTypeCode}";
            if (reqDto.getAcount() != null && reqDto.getCycleTypeCode() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount, String.valueOf(reqDto.getAcount()));
                retConent = retConent.replaceAll(cycleTypeCode, reqDto.getCycleTypeCode());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount, "---");
                retConent = retConent.replaceAll(cycleTypeCode, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（分工内容名称生成分工策略描述）
     * desc:undefined
     * gen by moon at 11/1/2022, 9:48:31 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（分工内容名称生成分工策略描述）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public DivisionContNameCreateDivisionDescRespDto divisionContNameCreateDivisionDesc(DivisionContNameCreateDivisionDescReqDto reqDto) {
        //当前目标由{divisionContName}牵头直接汇报即可
        Boolean bRetFlag = false;
        String retConent = "";
        DivisionContNameCreateDivisionDescRespDto retData = new DivisionContNameCreateDivisionDescRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("DIVISION_CONT_NAME_CREATE_DIVISION_DESC");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String divisionContName = "\\{divisionContName}";
            if (reqDto.getDivisionContName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(divisionContName, reqDto.getDivisionContName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(divisionContName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（编码名称生成分工策略描述）
     * desc:undefined
     * gen by moon at 11/1/2022, 9:48:37 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（编码名称生成分工策略描述）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CodeNameCreateDivisionDescRespDto codeNameCreateDivisionDesc(CodeNameCreateDivisionDescReqDto reqDto) {
        //当前目标{codeName}
        Boolean bRetFlag = false;
        String retConent = "";
        CodeNameCreateDivisionDescRespDto retData = new CodeNameCreateDivisionDescRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CODE_NAME_CREATE_DIVISION_DESC");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String codeName = "\\{codeName}";
            if (reqDto.getCodeName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(codeName, reqDto.getCodeName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(codeName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（评价模板批次名称模板）
     * desc:undefined
     * gen by moon at 11/1/2022, 9:48:43 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（评价模板批次名称模板）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateEvaTempBatchNameRespDto generateEvaTempBatchName(GenerateEvaTempBatchNameReqDto reqDto) {
        //{systemDateTime}{randomNumberDigits}{targetContentName}批次
        Boolean bRetFlag = false;
        String retConent = "";
        GenerateEvaTempBatchNameRespDto retData = new GenerateEvaTempBatchNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_EVA_TEMP_BATCH_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String systemDateTime = "\\{systemDateTime}";
            String randomNumberDigits = "\\{randomNumberDigits}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && !reqDto.getTargetContentName().isEmpty()) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(systemDateTime, CommonFunctionHelper.date2Str(CommonFunctionHelper.getCurrentTime()));
                Random random = new Random();
                String result = "";
                for (int i = 0; i < reqDto.getRandomNumberDigits(); i++) {
                    result += random.nextInt(10);
                }
                retConent = retConent.replaceAll(randomNumberDigits, result);
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（组织架构批次名称）
     * desc:undefined
     * gen by moon at 11/1/2022, 9:48:48 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（组织架构批次名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateOrgBatchNameRespDto createOrgBatchName(CreateOrgBatchNameReqDto reqDto) {
        //{systemDateTime}{sixRandomNum}{spaceName}组织编制批次
        Boolean bRetFlag = false;
        String retConent = "";
        CreateOrgBatchNameRespDto retData = new CreateOrgBatchNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_ORG_BATCH_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String systemDateTime = "\\{systemDateTime}";
            String sixRandomNum = "\\{sixRandomNum}";
            String spaceName = "\\{spaceName}";
            if (reqDto.getSpaceName() != null && !reqDto.getSpaceName().isEmpty()) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(spaceName, reqDto.getSpaceName());
                retConent = retConent.replaceAll(systemDateTime, CommonFunctionHelper.date2Str(CommonFunctionHelper.getCurrentTime()));
                Random random = new Random();
                String result = "";
                for (int i = 0; i < reqDto.getRandomNumberDigits(); i++) {
                    result += random.nextInt(10);
                }
                retConent = retConent.replaceAll(sixRandomNum, result);
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(spaceName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义内容服务（部门目标任务书树当前叶子调度任务名称）
     * desc:undefined
     * gen by moon at 11/3/2022, 9:54:03 PM
     **/
    @Trace(operationName = "M2生成语义内容服务（部门目标任务书树当前叶子调度任务名称）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateDeptTargetTreeLeafTaskNameRespDto createDeptTargetTreeLeafTaskName(CreateDeptTargetTreeLeafTaskNameReqDto reqDto) {
        //{objectiveShortName}：部门目标任务书树当前叶子调度任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateDeptTargetTreeLeafTaskNameRespDto retData = new CreateDeptTargetTreeLeafTaskNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_DEPT_TARGET_TREE_LEAF_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectiveShortName = "\\{objectiveShortName}";
            if (reqDto.getObjectiveShortName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectiveShortName, reqDto.getObjectiveShortName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectiveShortName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成校验目标周期不合理故事提示
     * desc:undefined
     * gen by moon at 11/20/2022, 12:10:11 AM
     **/
    @Trace(operationName = "M2生成校验目标周期不合理故事提示")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateSemanticContentServiceRespDto generateSemanticContentService(GenerateSemanticContentServiceReqDto reqDto) {
        //{cyclelAlias}下没有制定目标
        Boolean bRetFlag = false;
        String retConent = "";
        GenerateSemanticContentServiceRespDto retData = new GenerateSemanticContentServiceRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("TARGET_CYCLE_CHECK_IRRATIONAL_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias, reqDto.getCyclelAlias());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成参与者新增异常提示故事
     * desc:undefined
     * gen by moon at 12/5/2022, 1:57:08 PM
     **/
    @Trace(operationName = "M2生成参与者新增异常提示故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateParticipatorAbnormalStoryTipsRespDto createParticipatorAbnormalStoryTips(CreateParticipatorAbnormalStoryTipsReqDto reqDto) {
        //{idCardName}已是{virtualOrganizationPosition}，不能再设为参与者。
        Boolean bRetFlag = false;
        String retConent = "";
        CreateParticipatorAbnormalStoryTipsRespDto retData = new CreateParticipatorAbnormalStoryTipsRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_PARTICIPATOR_ABNORMAL_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String virtualOrganizationPosition = "\\{virtualOrganizationPosition}";
            if (reqDto.getIdCardName() != null && reqDto.getVirtualOrganizationPosition() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retConent = retConent.replaceAll(virtualOrganizationPosition, reqDto.getVirtualOrganizationPosition());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, "---");
                retConent = retConent.replaceAll(virtualOrganizationPosition, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成变更字段语义故事内容
     * desc:undefined
     * gen by moon at 12/5/2022, 1:57:13 PM
     **/
    @Trace(operationName = "M2-生成变更字段语义故事内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SubjectChangeContRespDto subjectChangeCont(SubjectChangeContReqDto reqDto) {
        //{reviseSubjectContent}{reviseBehaviorName}：{columnContent}
        Boolean bRetFlag = false;
        String retConent = "";
        SubjectChangeContRespDto retData = new SubjectChangeContRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUBJECT_CHANGE_CONT");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, "---");
                retConent = retConent.replaceAll(reviseBehaviorName, "---");
                retConent = retConent.replaceAll(columnContent, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成目标内容祖先目标父子状态调度任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:35:47 PM
     **/
    @Trace(operationName = "M2生成目标内容祖先目标父子状态调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateTargetContAnceParentStaTaskRespDto createTargetContAnceParentStaTask(CreateTargetContAnceParentStaTaskReqDto reqDto) {
        //{targetContentName}：目标内容祖先目标父子状态调度任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateTargetContAnceParentStaTaskRespDto retData = new CreateTargetContAnceParentStaTaskRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_TARGET_CONT_ANCE_PARENT_STA_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成评价模板调度汇报任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:35:52 PM
     **/
    @Trace(operationName = "M2生成评价模板调度汇报任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateTempCycleStageDispatchNameRespDto createTempCycleStageDispatchName(CreateTempCycleStageDispatchNameReqDto reqDto) {
        //{cyclelAlias}：生成评价模板调度汇报任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateTempCycleStageDispatchNameRespDto retData = new CreateTempCycleStageDispatchNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_TEMP_CYCLE_STAGE_DISPATCH_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCyclelAlias() != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias, reqDto.getCyclelAlias());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name: M2生成OKR个人树调度任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:35:58 PM
     **/
    @Trace(operationName = " M2生成OKR个人树调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateOkrPersonalTreeDataNameRespDto createOkrPersonalTreeDataName(CreateOkrPersonalTreeDataNameReqDto reqDto) {
        //生成{targetContentName}OKR个人树调度任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateOkrPersonalTreeDataNameRespDto retData = new CreateOkrPersonalTreeDataNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_OKR_PERSONAL_TREE_DATA_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成构建三棵树当前叶子及上级目标调度名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:36:03 PM
     **/
    @Trace(operationName = "M2生成构建三棵树当前叶子及上级目标调度名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto buildThreeTreeCurrentLeafAndSuperiorTaskName(BuildThreeTreeCurrentLeafAndSuperiorTaskNameReqDto reqDto) {
        //{targetContentName}：构建三棵树当前叶子及上级目标调度
        Boolean bRetFlag = false;
        String retConent = "";
        BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto retData = new BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("BUILD_THREE_TREE_CURRENT_LEAF_AND_SUPERIOR_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成调度自动更新权重分任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:36:09 PM
     **/
    @Trace(operationName = "M2生成调度自动更新权重分任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateTimingTaskAutoUpdateWeightScoreNameRespDto createTimingTaskAutoUpdateWeightScoreName(CreateTimingTaskAutoUpdateWeightScoreNameReqDto reqDto) {
        //{targetContentName}：下级内容目标周期权重分更新调度
        Boolean bRetFlag = false;
        String retConent = "";
        CreateTimingTaskAutoUpdateWeightScoreNameRespDto retData = new CreateTimingTaskAutoUpdateWeightScoreNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_TIMING_TASK_AUTO_UPDATE_WEIGHT_SCORE_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成调度生成汇报任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:36:14 PM
     **/
    @Trace(operationName = "M2-生成调度生成汇报任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateReportDispatchNameRespDto createReportDispatchName(CreateReportDispatchNameReqDto reqDto) {
        //{cycleStandardName}{targetContentName}：调度生成汇报任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateReportDispatchNameRespDto retData = new CreateReportDispatchNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_REPORT_DISPATCH_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成多循环更新检查项祖先状态调度名称
     * desc:undefined
     * gen by moon at 1/10/2023, 4:36:19 PM
     **/
    @Trace(operationName = "M2生成多循环更新检查项祖先状态调度名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto manyLoopUpdateCheckItemNodeStatusDispatchName(ManyLoopUpdateCheckItemNodeStatusDispatchNameReqDto reqDto) {
        //{targetContentName}：多循环更新检查项祖先状态调度
        Boolean bRetFlag = false;
        String retConent = "";
        ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto retData = new ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MANY_LOOP_UPDATE_CHECK_ITEM_NODE_STATUS_DISPATCH_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成删除目标内容基本信息调度任务名称
     * desc:undefined
     * gen by moon at 1/10/2023, 9:16:44 PM
     **/
    @Trace(operationName = "M2生成删除目标内容基本信息调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateDeleteTargetContInfoTaskNameRespDto createDeleteTargetContInfoTaskName(CreateDeleteTargetContInfoTaskNameReqDto reqDto) {
        //{systemDateTime}删除目标内容基本信息调度任务
        Boolean bRetFlag = false;
        String retConent = "";
        CreateDeleteTargetContInfoTaskNameRespDto retData = new CreateDeleteTargetContInfoTaskNameRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_DELETE_TARGET_CONT_INFO_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String systemDateTime = "\\{systemDateTime}";
            if (reqDto.getSystemDateTime() != null && reqDto.getSystemDateTime() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(systemDateTime, CommonFunctionHelper.date2Str(reqDto.getSystemDateTime()));
            } else {
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(systemDateTime, "---");
            }

            if (retConent != null && !retConent.isEmpty()) {
                retConent = retConent.replaceAll("---", "");
                retConent = retConent.replaceAll("（）", "");
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成权重或权重分未设置提示内容
     * desc:undefined
     * gen by moon at 1/26/2023, 11:40:41 AM
     **/
    @Trace(operationName = "M2生成权重或权重分未设置提示内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WeightAndScoreNotSetStoryTipsRespDto weightAndScoreNotSetStoryTips(WeightAndScoreNotSetStoryTipsReqDto reqDto) {
        //对不起，{cycleStandardName}{cyclelAlias}没有设权重或权重分！请重新设置~
        Boolean bRetFlag = false;
        String retConent = "";
        WeightAndScoreNotSetStoryTipsRespDto retData = new WeightAndScoreNotSetStoryTipsRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCycleStandardName() != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(cyclelAlias, reqDto.getCyclelAlias());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成权重总和不等于100故事提示
     * desc:undefined
     * gen by moon at 1/26/2023, 11:40:47 AM
     **/
    @Trace(operationName = "M2生成权重总和不等于100故事提示")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WeightSummationUnequalHundredStoryTipsRespDto weightSummationUnequalHundredStoryTips(WeightSummationUnequalHundredStoryTipsReqDto reqDto) {
        //对不起，{cycleStandardName}{cyclelAlias}下级设置的权重总和不等于100！请重新设置。~
        Boolean bRetFlag = false;
        String retConent = "";
        WeightSummationUnequalHundredStoryTipsRespDto retData = new WeightSummationUnequalHundredStoryTipsRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCycleStandardName() != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(cyclelAlias, reqDto.getCyclelAlias());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成权重分设置异常故事提示
     * desc:undefined
     * gen by moon at 1/26/2023, 11:40:52 AM
     **/
    @Trace(operationName = "M2生成权重分设置异常故事提示")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WeightScoreSetAbnormalStoryTipsRespDto weightScoreSetAbnormalStoryTips(WeightScoreSetAbnormalStoryTipsReqDto reqDto) {
        //对不起，{cycleStandardName}{cyclelAlias}下级内容设置的权重分总和不等于上级目标权重分！请重新设置~。
        Boolean bRetFlag = false;
        String retConent = "";
        WeightScoreSetAbnormalStoryTipsRespDto retData = new WeightScoreSetAbnormalStoryTipsRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCycleStandardName() != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(cyclelAlias, reqDto.getCyclelAlias());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成目标周期下未设置目标故事提示
     * desc:undefined
     * gen by moon at 1/26/2023, 11:40:58 AM
     **/
    @Trace(operationName = "M2生成目标周期下未设置目标故事提示")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TargetCycleBelowUnsetTargetStoryTipsRespDto targetCycleBelowUnsetTargetStoryTips(TargetCycleBelowUnsetTargetStoryTipsReqDto reqDto) {
        //对不起，{cycleStandardName}{cyclelAlias}工作周期下没有规划目标！请完整规划目标到工作周期~。
        Boolean bRetFlag = false;
        String retConent = "";
        TargetCycleBelowUnsetTargetStoryTipsRespDto retData = new TargetCycleBelowUnsetTargetStoryTipsRespDto();
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto.getCycleStandardName() != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(cyclelAlias, reqDto.getCyclelAlias());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成计算标准数据MQ调度任务名称
     * desc:undefined
     * gen by moon at 2/16/2023, 9:45:07 PM
     **/
    @Trace(operationName = "M2生成计算标准数据MQ调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateCalcTargetReportDataTaskNameRespDto createCalcTargetReportDataTaskName(CreateCalcTargetReportDataTaskNameReqDto reqDto) {
        //CREATE_CALC_TARGET_REPORT_DATA_TASK_NAME
        //{taskName}计算目标汇报数据调度任务
        CreateCalcTargetReportDataTaskNameRespDto retData = new CreateCalcTargetReportDataTaskNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_CALC_TARGET_REPORT_DATA_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String taskName = "\\{taskName}";
            if (reqDto.getTaskName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(taskName, reqDto.getTaskName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成托底更新目标内容父子状态调度任务名称
     * desc:undefined
     * gen by moon at 3/3/2023, 6:28:56 PM
     **/
    @Trace(operationName = "M2-生成托底更新目标内容父子状态调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateTorrUpdateContParentStatePlanNameRespDto createTorrUpdateContParentStatePlanName(CreateTorrUpdateContParentStatePlanNameReqDto reqDto) {
        //CREATE_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME
        //托底更新{targetContentName}：下级父子状态调度任务
        CreateTorrUpdateContParentStatePlanNameRespDto retData = new CreateTorrUpdateContParentStatePlanNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成平台托底更新目标内容父子状态调度任务名称
     * desc:undefined
     * gen by moon at 3/3/2023, 6:29:01 PM
     **/
    @Trace(operationName = "M2-生成平台托底更新目标内容父子状态调度任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreatePlaTorrUpdateContParentStatePlanNameRespDto createPlaTorrUpdateContParentStatePlanName(CreatePlaTorrUpdateContParentStatePlanNameReqDto reqDto) {
        //CREATE_PLA_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME
        //平台托底更新{targetContentName}：下级内容父子状态
        CreatePlaTorrUpdateContParentStatePlanNameRespDto retData = new CreatePlaTorrUpdateContParentStatePlanNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_PLA_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务自动汇报名称
     * desc:undefined
     * gen by moon at 3/3/2023, 11:29:07 PM
     **/
    @Trace(operationName = "M2生成汇报任务自动汇报名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateReportTaskAutoExecNameRespDto createReportTaskAutoExecName(CreateReportTaskAutoExecNameReqDto reqDto) {
        //CREATE_REPORT_TASK_AUTO_EXEC_NAME
        //{abbreviation}：汇报任务自动汇报调度
        CreateReportTaskAutoExecNameRespDto retData = new CreateReportTaskAutoExecNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_REPORT_TASK_AUTO_EXEC_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String abbreviation = "\\{abbreviation}";
            if (reqDto.getAbbreviation() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(abbreviation, reqDto.getAbbreviation());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成补偿目标内容检查项等调度名称
     * desc:undefined
     * gen by moon at 3/5/2023, 6:28:58 PM
     **/
    @Trace(operationName = "M2生成补偿目标内容检查项等调度名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateCompensationTargetContCheckEtcDisNameRespDto createCompensationTargetContCheckEtcDisName(CreateCompensationTargetContCheckEtcDisNameReqDto reqDto) {
        //CREATE_COMPENSATION_TARGET_CONT_CHECK_ETC_DIS_NAME
        //补偿{targetContentName}检查项等调度
        CreateCompensationTargetContCheckEtcDisNameRespDto retData = new CreateCompensationTargetContCheckEtcDisNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_COMPENSATION_TARGET_CONT_CHECK_ETC_DIS_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成向下更新目标设置等检查项状态调度名称
     * desc:undefined
     * gen by moon at 4/13/2023, 12:14:40 AM
     **/
    @Trace(operationName = "M2生成向下更新目标设置等检查项状态调度名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto createDownwardUpdateTargetSetCheckItemEtcStatePlanName(CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameReqDto reqDto) {
        //CREATE_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE_PLAN_NAME
        //向下更新“{targetContentName}”安排的指标目标设置检查项状态等
        CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto retData = new CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto();

        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE_PLAN_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作周期更新切片
     * desc:undefined
     * gen by moon at 4/16/2023, 12:13:09 AM
     **/
    @Trace(operationName = "M2-生成工作周期更新切片")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkCycleUpdateSliceRespDto workCycleUpdateSlice(WorkCycleUpdateSliceReqDto reqDto) {
        //WORK_CYCLE_UPDATE_SLICE
        //{parentSubMidCycleType}{customField1}{customField2}{customField3}
        WorkCycleUpdateSliceRespDto retData = new WorkCycleUpdateSliceRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_CYCLE_UPDATE_SLICE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String parentSubMidCycleType = "\\{parentSubMidCycleType}";
            String customField1 = "\\{customField1}";
            String customField2 = "\\{customField2}";
            String customField3 = "\\{customField3}";
            if (reqDto.getParentSubMidCycleType() != null && reqDto.getCustomField1() != null && reqDto.getCustomField2() != null && reqDto.getCustomField3() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(parentSubMidCycleType, reqDto.getParentSubMidCycleType());
                retConent = retConent.replaceAll(customField1, reqDto.getCustomField1());
                retConent = retConent.replaceAll(customField2, reqDto.getCustomField2());
                retConent = retConent.replaceAll(customField3, reqDto.getCustomField3());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:receptionService
     * name:约定出参：对象名称
     * desc:undefined
     * gen by moon at 4/28/2023, 3:50:16 PM
     **/
    @Trace(operationName = "约定出参：对象名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public QueryOutputParametersDetailRespDto queryOutputParametersDetail(QueryOutputParametersDetailReqDto reqDto) {
        return BeanUtil.toBean(reqDto, QueryOutputParametersDetailRespDto.class);
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订目标值故事内容
     * desc:undefined
     * gen by moon at 5/13/2023, 5:02:35 AM
     **/
    @Trace(operationName = "M2生成修订目标值故事内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ModifyTheTargetValueLogNameRespDto modifyTheTargetValueLogName(ModifyTheTargetValueLogNameReqDto reqDto) {
        //MODIFY_THE_TARGET_VALUE_LOG_NAME
        //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
        ModifyTheTargetValueLogNameRespDto retData = new ModifyTheTargetValueLogNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MODIFY_THE_TARGET_VALUE_LOG_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订权重语义故事
     * desc:undefined
     * gen by moon at 5/13/2023, 5:02:40 AM
     **/
    @Trace(operationName = "M2生成修订权重语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ModifyTheWeightLogNameRespDto modifyTheWeightLogName(ModifyTheWeightLogNameReqDto reqDto) {
        //MODIFY_THE_WEIGHT_LOG_NAME
        //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
        ModifyTheWeightLogNameRespDto retData = new ModifyTheWeightLogNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MODIFY_THE_WEIGHT_LOG_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订重新计算标准数据任务名称
     * desc:undefined
     * gen by moon at 5/13/2023, 9:05:48 PM
     **/
    @Trace(operationName = "M2生成修订重新计算标准数据任务名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReviseRecalculateDataTaskNameRespDto reviseRecalculateDataTaskName(ReviseRecalculateDataTaskNameReqDto reqDto) {
        //REVISE_RECALCULATE_DATA_TASK_NAME
        //{targetContentName}：修订重新计算标准数据任务
        ReviseRecalculateDataTaskNameRespDto retData = new ReviseRecalculateDataTaskNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REVISE_RECALCULATE_DATA_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订计划验收时间故事
     * desc:undefined
     * gen by moon at 5/17/2023, 3:41:32 AM
     **/
    @Trace(operationName = "M2生成修订计划验收时间故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ModifyReceiveTimeLogNameRespDto modifyReceiveTimeLogName(ModifyReceiveTimeLogNameReqDto reqDto) {
        //MODIFY_RECEIVE_TIME_LOG_NAME
        //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
        ModifyReceiveTimeLogNameRespDto retData = new ModifyReceiveTimeLogNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MODIFY_RECEIVE_TIME_LOG_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订目标周期名称语义故事
     * desc:undefined
     * gen by moon at 5/17/2023, 3:41:37 AM
     **/
    @Trace(operationName = "M2生成修订目标周期名称语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ModifyTargetCycleNameLogNameRespDto modifyTargetCycleNameLogName(ModifyTargetCycleNameLogNameReqDto reqDto) {
        //MODIFY_TARGET_CYCLE_NAME_LOG_NAME
        //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
        ModifyTargetCycleNameLogNameRespDto retData = new ModifyTargetCycleNameLogNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MODIFY_TARGET_CYCLE_NAME_LOG_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修订指标分工设置语义故事
     * desc:undefined
     * gen by moon at 5/17/2023, 11:17:32 PM
     **/
    @Trace(operationName = "M2生成修订指标分工设置语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ModifyObjtiveDivLogNameRespDto modifyObjtiveDivLogName(ModifyObjtiveDivLogNameReqDto reqDto) {
        //MODIFY_OBJTIVE_DIV_LOG_NAME
        //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
        ModifyObjtiveDivLogNameRespDto retData = new ModifyObjtiveDivLogNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MODIFY_OBJTIVE_DIV_LOG_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String reviseSubjectContent = "\\{reviseSubjectContent}";
            String reviseBehaviorName = "\\{reviseBehaviorName}";
            String columnContent = "\\{columnContent}";
            if (reqDto.getReviseSubjectContent() != null && reqDto.getReviseBehaviorName() != null && reqDto.getColumnContent() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent, reqDto.getReviseSubjectContent());
                retConent = retConent.replaceAll(reviseBehaviorName, reqDto.getReviseBehaviorName());
                retConent = retConent.replaceAll(columnContent, reqDto.getColumnContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成：邀请“ xx ” 加入小岛
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:33 PM
     **/
    @Trace(operationName = "M2生成：邀请“ xx ” 加入小岛")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateGroupDefaultPromptMessageRespDto createGroupDefaultPromptMessage(CreateGroupDefaultPromptMessageReqDto reqDto) {
        //CREATE_GROUP_DEFAULT_PROMPT_MESSAGE
        //邀请{idCardName}加入小岛。
        CreateGroupDefaultPromptMessageRespDto retData = new CreateGroupDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_GROUP_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成“我是**”
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:34 PM
     **/
    @Trace(operationName = "M2生成“我是**”")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TwoPeopleChatDefaultPromptMessageRespDto twoPeopleChatDefaultPromptMessage(TwoPeopleChatDefaultPromptMessageReqDto reqDto) {
        //TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE
        //我是{idCardName}。
        TwoPeopleChatDefaultPromptMessageRespDto retData = new TwoPeopleChatDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成：多人被“ xx ” 移出小岛
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:35 PM
     **/
    @Trace(operationName = "M2生成：多人被“ xx ” 移出小岛")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public KickOutMultDefaultPromptMessageRespDto kickOutMultDefaultPromptMessage(KickOutMultDefaultPromptMessageReqDto reqDto) {
        //KICK_OUT_SINGLE_DEFAULT_PROMPT_MESSAGE
        //被{idCardName}移出小岛。
        KickOutMultDefaultPromptMessageRespDto retData = new KickOutMultDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("KICK_OUT_SINGLE_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成：被“ xx ” 移出小岛
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:36 PM
     **/
    @Trace(operationName = "M2生成：被“ xx ” 移出小岛 ")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public KickOutSingleDefaultPromptMessageRespDto kickOutSingleDefaultPromptMessage(KickOutSingleDefaultPromptMessageReqDto reqDto) {
        //KICK_OUT_MULT_DEFAULT_PROMPT_MESSAGE
        //多人被{idCardName}移出小岛。
        KickOutSingleDefaultPromptMessageRespDto retData = new KickOutSingleDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("KICK_OUT_MULT_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成 “ xx ” 邀请多人加入小岛
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:37 PM
     **/
    @Trace(operationName = "M2生成 “ xx ” 邀请多人加入小岛")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateMultGroupDefaultPromptMessageRespDto createMultGroupDefaultPromptMessage(CreateMultGroupDefaultPromptMessageReqDto reqDto) {
        //CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE
        //{idCardName}邀请多人加入小岛。
        CreateMultGroupDefaultPromptMessageRespDto retData = new CreateMultGroupDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成：“ xx ” 退出小岛
     * desc:undefined
     * gen by moon at 5/31/2023, 6:08:38 PM
     **/
    @Trace(operationName = "M2生成：“ xx ” 退出小岛")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ActiveQuitDefaultPromptMessageRespDto activeQuitDefaultPromptMessage(ActiveQuitDefaultPromptMessageReqDto reqDto) {
        ///ACTIVE_QUIT_DEFAULT_PROMPT_MESSAGE
        //{idCardName}退出小岛。
        ActiveQuitDefaultPromptMessageRespDto retData = new ActiveQuitDefaultPromptMessageRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ACTIVE_QUIT_DEFAULT_PROMPT_MESSAGE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成全模板网格计算标准数据任务名称
     * desc:undefined
     * gen by moon at 6/2/2023, 2:35:04 PM
     **/
    @Trace(operationName = "M2-生成全模板网格计算标准数据任务名称	")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public DispatchExecuteGridCalcTaskNameRespDto dispatchExecuteGridCalcTaskName(DispatchExecuteGridCalcTaskNameReqDto reqDto) {
        //DISPATCH_EXECUTE_GRID_CALC_TASK_NAME
        //{targetContentName}全模版网格计算标准数据任务
        DispatchExecuteGridCalcTaskNameRespDto retData = new DispatchExecuteGridCalcTaskNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("DISPATCH_EXECUTE_GRID_CALC_TASK_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            String cycleStandardName = "\\{cycleStandardName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成目标内容管理锁主键
     * desc:undefined
     * gen by moon at 6/26/2023, 9:48:25 PM
     **/
    @Trace(operationName = "M2生成目标内容管理锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TargetContMgtKeyRespDto targetContMgtKey(TargetContMgtKeyReqDto reqDto) {
        //{evaluationTemplateId}{conEntityId}
        //TARGET_CONT_MGT_KEY
        TargetContMgtKeyRespDto retData = new TargetContMgtKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("TARGET_CONT_MGT_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String entityId = "\\{entityId}";
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEntityId() != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(entityId, reqDto.getEntityId());
                retConent = retConent.replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成新增模板全内容计算异步锁名称
     * desc:undefined
     * gen by moon at 6/26/2023, 9:48:31 PM
     **/
    @Trace(operationName = "M2生成新增模板全内容计算异步锁名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TempAllContentCalcLockKeyRespDto tempAllContentCalcLockKey(TempAllContentCalcLockKeyReqDto reqDto) {
        //ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY
        TempAllContentCalcLockKeyRespDto retData = new TempAllContentCalcLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成执行模板全内容计算异步锁名称
     * desc:undefined
     * gen by moon at 6/26/2023, 9:48:37 PM
     **/
    @Trace(operationName = "M2生成执行模板全内容计算异步锁名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ExecTempAllContentCalcLockKeyRespDto execTempAllContentCalcLockKey(ExecTempAllContentCalcLockKeyReqDto reqDto) {
        //EXEC_TEMP_ALL_CONTENT_CALC_LOCK_KEY
        ExecTempAllContentCalcLockKeyRespDto retData = new ExecTempAllContentCalcLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("EXEC_TEMP_ALL_CONTENT_CALC_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成新增模版数据重计算异步锁名称
     * desc:undefined
     * gen by moon at 6/29/2023, 2:03:29 AM
     **/
    @Trace(operationName = "M2-生成新增模版数据重计算异步锁名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddTempAllContentRecalcLockKeyRespDto addTempAllContentRecalcLockKey(AddTempAllContentRecalcLockKeyReqDto reqDto) {
        //ADD_TEMP_ALL_CONTENT_RECALC_LOCK_KEY
        //addRecalc_{evaluationTemplateId}
        AddTempAllContentRecalcLockKeyRespDto retData = new AddTempAllContentRecalcLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_RECALC_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成增目标内容调度锁主键
     * desc:undefined
     * gen by moon at 6/30/2023, 10:39:55 PM
     **/
    @Trace(operationName = "M2生成增目标内容调度锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddTargetContDispatchKeyRespDto addTargetContDispatchKey(AddTargetContDispatchKeyReqDto reqDto) {
        //ADD_TARGET_CONT_DISPATCH_KEY
        //dispatch_{evaluationTemplateId}{entityId}
        AddTargetContDispatchKeyRespDto retData = new AddTargetContDispatchKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ADD_TARGET_CONT_DISPATCH_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成全模版汇报任务锁名称
     * desc:undefined
     * gen by moon at 7/5/2023, 4:31:38 PM
     **/
    @Trace(operationName = "M2生成全模版汇报任务锁名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddTempAllReportTaskLockKeyRespDto addTempAllReportTaskLockKey(AddTempAllReportTaskLockKeyReqDto reqDto) {
        // TODO ruizhe skai dong ; 7/5/2023, 4:31:38 PM

        //ADD_TEMP_ALL_REPORT_TASK_LOCK_KEY
        // addReportTask_{evaluationTemplateId}
        AddTempAllReportTaskLockKeyRespDto retData = new AddTempAllReportTaskLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_REPORT_TASK_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成高层下发指标锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:49:40 PM
     **/
    @Trace(operationName = "M2生成高层下发指标锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TopIusseObjLockKeyRespDto topIusseObjLockKey(TopIusseObjLockKeyReqDto reqDto) {
        //TOP_IUSSE_OBJ_LOCK_KEY
        //topIusseObj{evaluationTemplateId}
        TopIusseObjLockKeyRespDto retData = new TopIusseObjLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("TOP_IUSSE_OBJ_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成中层下发指标锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:49:46 PM
     **/
    @Trace(operationName = "M2生成中层下发指标锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public MidIusseObjLockKeyRespDto midIusseObjLockKey(MidIusseObjLockKeyReqDto reqDto) {
        //MID_IUSSE_OBJ_LOCK_KEY
        //midIusse{entityId}{evaluationTemplateId}
        MidIusseObjLockKeyRespDto retData = new MidIusseObjLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MID_IUSSE_OBJ_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成基层下发指标锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:49:52 PM
     **/
    @Trace(operationName = "M2生成基层下发指标锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public BasicIusseObjLockKeyRespDto basicIusseObjLockKey(BasicIusseObjLockKeyReqDto reqDto) {
        //BASIC_IUSSE_OBJ_LOCK_KEY
        //basicIusse{entityId}{evaluationTemplateId}
        BasicIusseObjLockKeyRespDto retData = new BasicIusseObjLockKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("BASIC_IUSSE_OBJ_LOCK_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成高层返回第一步锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:49:58 PM
     **/
    @Trace(operationName = "M2生成高层返回第一步锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public TopRollbackFirstKeyRespDto topRollbackFirstKey(TopRollbackFirstKeyReqDto reqDto) {
        //TOP_ROLLBACK_FIRST_KEY
        //topRollbackFirst{evaluationTemplateId}
        TopRollbackFirstKeyRespDto retData = new TopRollbackFirstKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("TOP_ROLLBACK_FIRST_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成中层返回上一步锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:50:04 PM
     **/
    @Trace(operationName = "M2生成中层返回上一步锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public MidRollbackLastStepKeyRespDto midRollbackLastStepKey(MidRollbackLastStepKeyReqDto reqDto) {
        //MID_ROLLBACK_LAST_STEP_KEY
        //midRollbackLastStep{entityId}{evaluationTemplateId}
        MidRollbackLastStepKeyRespDto retData = new MidRollbackLastStepKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MID_ROLLBACK_LAST_STEP_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成基层返回第一步锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 7:50:09 PM
     **/
    @Trace(operationName = "M2生成基层返回第一步锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public BasicRollbackFirstKeyRespDto basicRollbackFirstKey(BasicRollbackFirstKeyReqDto reqDto) {
        //BASIC_ROLLBACK_FIRST_KEY
        //basicRollbackFirst{entityId}{evaluationTemplateId}
        BasicRollbackFirstKeyRespDto retData = new BasicRollbackFirstKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("BASIC_ROLLBACK_FIRST_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成执行进度锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 10:26:32 PM
     **/
    @Trace(operationName = "M2生成执行进度锁主键")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ExecuteProgressKeyRespDto executeProgressKey(ExecuteProgressKeyReqDto reqDto) {
        //EXECUTE_PROGRESS_KEY
        //progress{entityId}{evaluationTemplateId}
        ExecuteProgressKeyRespDto retData = new ExecuteProgressKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("EXECUTE_PROGRESS_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if (reqDto != null && reqDto.getEvaluationTemplateId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId, reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId, reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成内容会话通道名称
     * desc:undefined
     * gen by moon at 8/1/2023, 9:12:36 PM
     **/
    @Trace(operationName = "M2生成内容会话通道名称")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ContentSessionChannelNameRespDto contentSessionChannelName(ContentSessionChannelNameReqDto reqDto) {
        //CONTENT_SESSION_CHANNEL_NAME
        //{cyclelAlias}
        ContentSessionChannelNameRespDto retData = new ContentSessionChannelNameRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CONTENT_SESSION_CHANNEL_NAME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cyclelAlias = "\\{cyclelAlias}";
            if (reqDto != null && reqDto.getCyclelAlias() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias, reqDto.getCyclelAlias());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报问答提问内容
     * desc:undefined
     * gen by moon at 8/6/2023, 12:28:35 PM
     **/
    @Trace(operationName = "M2生成汇报问答提问内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportQaContentRespDto reportQaContent(ReportQaContentReqDto reqDto) {
        //CREATE_CONT_QA_MSG_CONTNET
        //基于“{objectName}”任务，{cycleStandardName}
        // 进度：{progressValue}{progressValueUnit}较上一周期{progressFromLastRatio}{progressValueUnit}
        // ，实际值：{actualValue}{actualValueUnit}较上一周期{fromLastTargetLiftRatio}{actualValueUnit}
        // ，达成度：{reach}{reachUnit}较上一周期{actualFromLastTimeRatio}{reachUnit}
        // ，汇报得分：{reportScoreValue}{reportScoreUnit}较上一周期{reportScoreFromLastRatio}{reportScoreUnit}。
        // 根据以上信息生成汇报内容
        ReportQaContentRespDto retData = new ReportQaContentRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_CONT_QA_MSG_CONTNET");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String objectName = "\\{objectName}";
            retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
            retConent = retConent.replaceAll(objectName, reqDto.getObjectName());
            if (reqDto.getProgressValue() != null) {
                String progressValue = "\\{progressValue}";
                String progressValueUnit = "\\{progressValueUnit}";
                retConent = retConent.replaceAll(progressValue, String.valueOf(reqDto.getProgressValue()));
                retConent = retConent.replaceAll(progressValueUnit, reqDto.getProgressValueUnit());
                if (reqDto.getProgressFromLastRatio() != null) {
                    String progressFromLastRatio = "\\{progressFromLastRatio}";
                    retConent = retConent.replaceAll(progressFromLastRatio, String.valueOf(reqDto.getProgressFromLastRatio()));
                    retConent = retConent.replaceAll(progressValueUnit, String.valueOf(reqDto.getProgressValueUnit()));
                } else {
                    String replaceKeyStr = "较上一周期\\{progressFromLastRatio}" + String.valueOf(reqDto.getProgressValueUnit());
                    retConent = retConent.replaceAll(replaceKeyStr, "");
                }
            } else {
                retConent = retConent.replaceAll("进度：\\{progressValue}\\{progressValueUnit}较上一周期\\{progressFromLastRatio}\\{progressValueUnit}，", "");
            }

            if (reqDto.getActualValue() != null) {
                String actualValue = "\\{actualValue}";
                String actualValueUnit = "\\{actualValueUnit}";
                retConent = retConent.replaceAll(actualValue, String.valueOf(reqDto.getActualValue()));
                retConent = retConent.replaceAll(actualValueUnit, reqDto.getActualValueUnit());
                if (reqDto.getFromLastTargetLiftRatio() != null) {
                    String fromLastTargetLiftRatio = "\\{fromLastTargetLiftRatio}";
                    retConent = retConent.replaceAll(fromLastTargetLiftRatio, String.valueOf(reqDto.getFromLastTargetLiftRatio()));
                    retConent = retConent.replaceAll(actualValueUnit, String.valueOf(reqDto.getActualValueUnit()));
                } else {
                    String replaceKeyStr = "较上一周期\\{fromLastTargetLiftRatio}" + String.valueOf(reqDto.getActualValueUnit());
                    retConent = retConent.replaceAll(replaceKeyStr, "");
                }
            } else {
                retConent = retConent.replaceAll("实际值：\\{actualValue}\\{actualValueUnit}较上一周期\\{fromLastTargetLiftRatio}\\{actualValueUnit}，", "");
            }

            if (reqDto.getReach() != null) {
                String reach = "\\{reach}";
                String reachUnit = "\\{reachUnit}";
                retConent = retConent.replaceAll(reach, String.valueOf(reqDto.getReach()));
                retConent = retConent.replaceAll(reachUnit, reqDto.getReachUnit());
                if (reqDto.getActualFromLastTimeRatio() != null) {
                    String actualFromLastTimeRatio = "\\{actualFromLastTimeRatio}";
                    retConent = retConent.replaceAll(actualFromLastTimeRatio, String.valueOf(reqDto.getActualFromLastTimeRatio()));
                    retConent = retConent.replaceAll(reachUnit, String.valueOf(reqDto.getReachUnit()));
                } else {
                    String replaceKeyStr = "较上一周期\\{actualFromLastTimeRatio}" + String.valueOf(reqDto.getReachUnit());
                    retConent = retConent.replaceAll(replaceKeyStr, "");
                }
            } else {
                retConent = retConent.replaceAll("达成度：\\{reach}\\{reachUnit}较上一周期\\{actualFromLastTimeRatio}\\{reachUnit}，", "");
            }

            if (reqDto.getReportScoreValue() != null) {
                String reportScoreValue = "\\{reportScoreValue}";
                String reportScoreUnit = "\\{reportScoreUnit}";
                retConent = retConent.replaceAll(reportScoreValue, String.valueOf(reqDto.getReportScoreValue()));
                retConent = retConent.replaceAll(reportScoreUnit, reqDto.getReportScoreUnit());
                if (reqDto.getReportScoreFromLastRatio() != null) {
                    String reportScoreFromLastRatio = "\\{reportScoreFromLastRatio}";
                    retConent = retConent.replaceAll(reportScoreFromLastRatio, String.valueOf(reqDto.getReportScoreFromLastRatio()));
                    retConent = retConent.replaceAll(reportScoreUnit, String.valueOf(reqDto.getReportScoreUnit()));
                } else {
                    String replaceKeyStr = "较上一周期\\{reportScoreFromLastRatio}" + String.valueOf(reqDto.getReportScoreUnit());
                    retConent = retConent.replaceAll(replaceKeyStr, "");
                }
            } else {
                retConent = retConent.replaceAll("，汇报得分：\\{reportScoreValue}\\{reportScoreUnit}较上一周期\\{reportScoreFromLastRatio}\\{reportScoreUnit}", "");
            }
            retData.setObjectName(retConent);
        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成分布式锁主题批次
     * desc:undefined
     * gen by moon at 10/1/2023, 12:34:07 AM
     **/
    @Trace(operationName = "M2生成分布式锁主题批次")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public DistributedLockMotifBatchRespDto distributedLockMotifBatch(DistributedLockMotifBatchReqDto reqDto) {

        //DISTRIBUTED_LOCK_MOTIF_BATCH
        //{commPrimaryKey}{systemDateTime}
        DistributedLockMotifBatchRespDto retData = new DistributedLockMotifBatchRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("DISTRIBUTED_LOCK_MOTIF_BATCH");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String commPrimaryKey = "\\{commPrimaryKey}";
            String systemDateTime = "\\{systemDateTime}";
            if (reqDto != null && reqDto.getCommPrimaryKey() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(commPrimaryKey, reqDto.getCommPrimaryKey());
                retConent = retConent.replaceAll(systemDateTime, CommonFunctionHelper.date2Str(reqDto.getSystemDateTime()));
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成新汇报任务消息标题
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:23 PM
     **/
    @Trace(operationName = "M2生成新汇报任务消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public NewReportTaskMsgTitleRespDto newReportTaskMsgTitle(NewReportTaskMsgTitleReqDto reqDto) {
        //NEW_REPORT_TASK_MSG_TITLE
        //{cycleStandardName}的{targetContentName}目标有新汇报
        NewReportTaskMsgTitleRespDto retData = new NewReportTaskMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("NEW_REPORT_TASK_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成新汇报任务消息内容
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:29 PM
     **/
    @Trace(operationName = "M2生成新汇报任务消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public NewReportTaskMsgRespDto newReportTaskMsg(NewReportTaskMsgReqDto reqDto) {
        //NEW_REPORT_TASK_MSG
        //{cycleStandardName}的{targetContentName}目标有新汇报任务，请按时汇报~
        NewReportTaskMsgRespDto retData = new NewReportTaskMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("NEW_REPORT_TASK_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报即将逾期消息标题
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:34 PM
     **/
    @Trace(operationName = "M2生成汇报即将逾期消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskWillOverdueMsgTitleRespDto reportTaskWillOverdueMsgTitle(ReportTaskWillOverdueMsgTitleReqDto reqDto) {
        //REPORT_TASK_WILL_OVERDUE_MSG_TITLE
        //{cycleStandardName}的{targetContentName}目标汇报即将逾期
        ReportTaskWillOverdueMsgTitleRespDto retData = new ReportTaskWillOverdueMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_WILL_OVERDUE_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报即将逾期消息内容
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:40 PM
     **/
    @Trace(operationName = "M2生成汇报即将逾期消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskWillOverdueMsgRespDto reportTaskWillOverdueMsg(ReportTaskWillOverdueMsgReqDto reqDto) {
        //REPORT_TASK_WILL_OVERDUE_MSG
        //{idCardName}你{cycleStandardName}的{targetContentName}目标汇报任务即将逾期，请及时汇报~
        ReportTaskWillOverdueMsgRespDto retData = new ReportTaskWillOverdueMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_WILL_OVERDUE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报已逾期消息标题
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:46 PM
     **/
    @Trace(operationName = "M2生成汇报已逾期消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskOverdueMsgTitleRespDto reportTaskOverdueMsgTitle(ReportTaskOverdueMsgTitleReqDto reqDto) {
        //{cycleStandardName}的{targetContentName}目标汇报已逾期
        //REPORT_TASK_OVERDUE_MSG_TITLE
        ReportTaskOverdueMsgTitleRespDto retData = new ReportTaskOverdueMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_OVERDUE_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报已逾期消息内容
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:52 PM
     **/
    @Trace(operationName = "M2生成汇报已逾期消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskOverdueMsgRespDto reportTaskOverdueMsg(ReportTaskOverdueMsgReqDto reqDto) {
        //{idCardName}你{cycleStandardName}的{targetContentName}目标汇报任务已逾期，要赶快汇报哦~
        //REPORT_TASK_OVERDUE_MSG
        ReportTaskOverdueMsgRespDto retData = new ReportTaskOverdueMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_OVERDUE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成新目标安排消息标题
     * desc:undefined
     * gen by moon at 10/4/2023, 10:15:58 PM
     **/
    @Trace(operationName = "M2生成新目标安排消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public NewTargetArrangeMsgTitleRespDto newTargetArrangeMsgTitle(NewTargetArrangeMsgTitleReqDto reqDto) {
        //新目标安排 {targetContentName}
        //NEW_TARGET_ARRANGE_MSG_TITLE
        NewTargetArrangeMsgTitleRespDto retData = new NewTargetArrangeMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("NEW_TARGET_ARRANGE_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成新目标安排消息内容
     * desc:undefined
     * gen by moon at 10/4/2023, 10:16:04 PM
     **/
    @Trace(operationName = "M2生成新目标安排消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public NewTargetArrangeMsgRespDto newTargetArrangeMsg(NewTargetArrangeMsgReqDto reqDto) {
        //{idCardName}你有新的目标安排：{targetContentName}
        //NEW_TARGET_ARRANGE_MSG
        NewTargetArrangeMsgRespDto retData = new NewTargetArrangeMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("NEW_TARGET_ARRANGE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String dutyBodyName = "\\{dutyBodyName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getDutyBodyName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(dutyBodyName, reqDto.getDutyBodyName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务提交消息标题
     * desc:undefined
     * gen by moon at 10/10/2023, 1:45:49 AM
     **/
    @Trace(operationName = "M2生成汇报任务提交消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskMsgTitleRespDto reportTaskMsgTitle(ReportTaskMsgTitleReqDto reqDto) {
        //REPORT_TASK_MSG_TITLE
        //{targetContentName}...{cycleStandardName}汇报
        ReportTaskMsgTitleRespDto retData = new ReportTaskMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成催办目标安排消息内容
     * desc:undefined
     * gen by moon at 10/14/2023, 11:32:30 PM
     **/
    @Trace(operationName = "M2生成催办目标安排消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public UrgeTargetArrangeMsgTempRespDto urgeTargetArrangeMsgTemp(UrgeTargetArrangeMsgTempReqDto reqDto) {
        //URGE_TARGET_ARRANGE_MSG_TEMP
        //{deptShortName}请尽快完成目标安排
        UrgeTargetArrangeMsgTempRespDto retData = new UrgeTargetArrangeMsgTempRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("URGE_TARGET_ARRANGE_MSG_TEMP");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String deptShortName = "\\{deptShortName}";
            if (reqDto != null && reqDto.getDeptShortName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName, reqDto.getDeptShortName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务待评价消息标题
     * desc:undefined
     * gen by moon at 10/14/2023, 11:32:37 PM
     **/
    @Trace(operationName = "M2生成汇报任务待评价消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskToBeEvaluateedMsgTitleRespDto reportTaskToBeEvaluateedMsgTitle(ReportTaskToBeEvaluateedMsgTitleReqDto reqDto) {
        //REPORT_TASK_TO_BE_EVALUATEED_MSG_TITLE
        //{cycleStandardName}的{targetContentName}汇报已提交，请及时评价
        ReportTaskToBeEvaluateedMsgTitleRespDto retData = new ReportTaskToBeEvaluateedMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EVALUATEED_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成中基层催办目标安排消息
     * desc:undefined
     * gen by moon at 10/14/2023, 11:32:43 PM
     **/
    @Trace(operationName = "M2生成中基层催办目标安排消息")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public MidBasicUrgeTargetArrangeMsgTempRespDto midBasicUrgeTargetArrangeMsgTemp(MidBasicUrgeTargetArrangeMsgTempReqDto reqDto) {
        //MID_BASIC_URGE_TARGET_ARRANGE_MSG_TEMP
        //{deptShortName}你部门有{comNumField}个目标未安排，请尽快完成~
        MidBasicUrgeTargetArrangeMsgTempRespDto retData = new MidBasicUrgeTargetArrangeMsgTempRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("MID_BASIC_URGE_TARGET_ARRANGE_MSG_TEMP");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String deptShortName = "\\{deptShortName}";
            String comNumField = "\\{comNumField}";
            if (reqDto != null && reqDto.getDeptShortName() != null && reqDto.getComNumField() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName, reqDto.getDeptShortName());
                retConent = retConent.replaceAll(comNumField, String.valueOf(reqDto.getComNumField()));
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务待审核消息标题
     * desc:undefined
     * gen by moon at 10/14/2023, 11:32:49 PM
     **/
    @Trace(operationName = "M2生成汇报任务待审核消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskToBeExamineMsgTitleRespDto reportTaskToBeExamineMsgTitle(ReportTaskToBeExamineMsgTitleReqDto reqDto) {
        //REPORT_TASK_TO_BE_EXAMINE_MSG_TITLE
        //{cycleStandardName}的{targetContentName}评价已完成，请及时审核
        ReportTaskToBeExamineMsgTitleRespDto retData = new ReportTaskToBeExamineMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EXAMINE_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务待审核消息内容
     * desc:undefined
     * gen by moon at 10/14/2023, 11:32:55 PM
     **/
    @Trace(operationName = "M2生成汇报任务待审核消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskToBeExamineMsgRespDto reportTaskToBeExamineMsg(ReportTaskToBeExamineMsgReqDto reqDto) {
        //REPORT_TASK_TO_BE_EXAMINE_MSG
        //{cycleStandardName}的{targetContentName}目标汇报任务已完成，该汇报任务的审核人及时处理
        ReportTaskToBeExamineMsgRespDto retData = new ReportTaskToBeExamineMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EXAMINE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务审核驳回消息标题
     * desc:undefined
     * gen by moon at 10/14/2023, 11:33:01 PM
     **/
    @Trace(operationName = "M2生成汇报任务审核驳回消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskRejectMsgTitleRespDto reportTaskRejectMsgTitle(ReportTaskRejectMsgTitleReqDto reqDto) {
        //REPORT_TASK_REJECT_MSG_TITLE
        //{cycleStandardName}的{targetContentName}汇报被驳回，请及时处理
        ReportTaskRejectMsgTitleRespDto retData = new ReportTaskRejectMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REJECT_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务审核驳回内容
     * desc:undefined
     * gen by moon at 10/14/2023, 11:33:07 PM
     **/
    @Trace(operationName = "M2生成汇报任务审核驳回内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskRejectMsgRespDto reportTaskRejectMsg(ReportTaskRejectMsgReqDto reqDto) {
        //REPORT_TASK_REJECT_MSG
        //{cycleStandardName}的{targetContentName}汇报任务被驳回，请及时处理。驳回原因：{reportTaskRejectReason}。
        ReportTaskRejectMsgRespDto retData = new ReportTaskRejectMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REJECT_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            String reportTaskRejectReason = "\\{reportTaskRejectReason}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                if (reqDto.getReportTaskRejectReason() != null) {
                    retConent = retConent.replaceAll(reportTaskRejectReason, reqDto.getReportTaskRejectReason());
                } else {
                    retConent = retConent.replaceAll(reportTaskRejectReason, "");
                }
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成修改目标值消息
     * desc:undefined
     * gen by moon at 10/14/2023, 11:33:13 PM
     **/
    @Trace(operationName = "M2生成修改目标值消息")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public UpdateTargetValueMsgTempRespDto updateTargetValueMsgTemp(UpdateTargetValueMsgTempReqDto reqDto) {
        //UPDATE_TARGET_VALUE_MSG_TEMP
        //{idCardName}负责的{targetContentName}的目标值有调整，请检查确认~
        UpdateTargetValueMsgTempRespDto retData = new UpdateTargetValueMsgTempRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("UPDATE_TARGET_VALUE_MSG_TEMP");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getIdCardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务待评价消息内容
     * desc:undefined
     * gen by moon at 10/15/2023, 6:09:07 PM
     **/
    @Trace(operationName = "M2生成汇报任务待评价消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskToBeEvaluateedMsgRespDto reportTaskToBeEvaluateedMsg(ReportTaskToBeEvaluateedMsgReqDto reqDto) {
        //REPORT_TASK_TO_BE_EVALUATEED_MSG
        //{cycleStandardName}的{targetContentName}目标汇报任务已提交，该汇报任务的评价人及时处理
        ReportTaskToBeEvaluateedMsgRespDto retData = new ReportTaskToBeEvaluateedMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EVALUATEED_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成websocket消息主题
     * desc:undefined
     * gen by moon at 10/20/2023, 9:25:22 AM
     **/
    @Trace(operationName = "M2-生成websocket消息主题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WebsocketMsgThemeRespDto websocketMsgTheme(WebsocketMsgThemeReqDto reqDto) {
        //WEBSOCKET_MSG_THEME
        //{originalRoleMemberId}messageTheme
        WebsocketMsgThemeRespDto retData = new WebsocketMsgThemeRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WEBSOCKET_MSG_THEME");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String originalRoleMemberId = "\\{originalRoleMemberId}";
            if (reqDto != null && reqDto.getOriginalRoleMemberId() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(originalRoleMemberId, reqDto.getOriginalRoleMemberId());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务提醒消息标题
     * desc:undefined
     * gen by moon at 10/22/2023, 7:21:08 PM
     **/
    @Trace(operationName = "M2生成汇报任务提醒消息标题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskRemindMsgTitleRespDto reportTaskRemindMsgTitle(ReportTaskRemindMsgTitleReqDto reqDto) {
        //{cycleStandardName}的{targetContentName}请及时汇报
        //REPORT_TASK_REMIND_MSG_TITLE
        ReportTaskRemindMsgTitleRespDto retData = new ReportTaskRemindMsgTitleRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REMIND_MSG_TITLE");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务提醒消息内容
     * desc:undefined
     * gen by moon at 10/22/2023, 7:21:15 PM
     **/
    @Trace(operationName = "M2生成汇报任务提醒消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ReportTaskRemindMsgRespDto reportTaskRemindMsg(ReportTaskRemindMsgReqDto reqDto) {
        //{cycleStandardName}的{targetContentName}还未汇报完成，请及时汇报~
        //REPORT_TASK_REMIND_MSG
        ReportTaskRemindMsgRespDto retData = new ReportTaskRemindMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REMIND_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:invokeTemplateSemantic
     * name:M2生成加预算流水业务故事
     * desc:undefined
     * gen by moon at 11/6/2023, 5:56:43 PM
     **/
    @Trace(operationName = "M2生成加预算流水业务故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateAddBudgetStoryRespDto createAddBudgetStory(CreateAddBudgetStoryReqDto reqDto) {
        //CREATE_ADD_BUDGET_STORY
        //{idCardName}减少{targetContentName}预算
        CreateAddBudgetStoryRespDto retData = new CreateAddBudgetStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_ADD_BUDGET_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getTargetContentName() != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:invokeTemplateSemantic
     * name:M2生成减预算流水业务故事
     * desc:undefined
     * gen by moon at 11/6/2023, 5:56:51 PM
     **/
    @Trace(operationName = "M2生成减预算流水业务故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CreateSubTractBudgetStoryRespDto createSubTractBudgetStory(CreateSubTractBudgetStoryReqDto reqDto) {
        //CREATE_SUBTRACT_BUDGET_STORY
        //{idCardName}减少{targetContentName}预算
        CreateSubTractBudgetStoryRespDto retData = new CreateSubTractBudgetStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CREATE_SUBTRACT_BUDGET_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            String idCardName = "\\{idCardName}";
            if (reqDto != null && reqDto.getTargetContentName() != null && reqDto.getIdCardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成预算到账账单流水业务故事
     * desc:undefined
     * gen by moon at 11/6/2023, 5:56:59 PM
     **/
    @Trace(operationName = "M2生成预算到账账单流水业务故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public BudgetArrivalStoryRespDto budgetArrivalStory(BudgetArrivalStoryReqDto reqDto) {
        //BUDGET_ARRIVAL_STORY
        //{targetContentName}资金到账
        BudgetArrivalStoryRespDto retData = new BudgetArrivalStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("BUDGET_ARRIVAL_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成费用支出流水业务故事
     * desc:undefined
     * gen by moon at 11/6/2023, 5:57:08 PM
     **/
    @Trace(operationName = "M2-生成费用支出流水业务故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ChargeExpenditureStoryRespDto chargeExpenditureStory(ChargeExpenditureStoryReqDto reqDto) {
        //CHARGE_EXPENDITURE_STORY
        //{accountSubjectName}支出
        ChargeExpenditureStoryRespDto retData = new ChargeExpenditureStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("CHARGE_EXPENDITURE_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String accountSubjectName = "\\{accountSubjectName}";
            if (reqDto != null && reqDto.getAccountSubjectName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(accountSubjectName, reqDto.getAccountSubjectName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成提醒签收工作任务消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:03 PM
     **/
    @Trace(operationName = "M2生成提醒签收工作任务消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public RemindSignWorkTaskMsgRespDto remindSignWorkTaskMsg(RemindSignWorkTaskMsgReqDto reqDto) {
        //您的工作任务：{targetContentName}还未签收，请及时处理。
        //REMIND_SIGN_WORK_TASK_MSG
        RemindSignWorkTaskMsgRespDto retData = new RemindSignWorkTaskMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REMIND_SIGN_WORK_TASK_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成督办工作任务消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:10 PM
     **/
    @Trace(operationName = "M2-生成督办工作任务消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public RemindHandleWorkTaskMsgRespDto remindHandleWorkTaskMsg(RemindHandleWorkTaskMsgReqDto reqDto) {
        //您的工作任务：{targetContentName}还未完成，请及时处理。
        //REMIND_HANDLE_WORK_TASK_MSG
        RemindHandleWorkTaskMsgRespDto retData = new RemindHandleWorkTaskMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REMIND_HANDLE_WORK_TASK_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成督办问题消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:16 PM
     **/
    @Trace(operationName = "M2生成督办问题消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public RemindHandleProblemMsgRespDto remindHandleProblemMsg(RemindHandleProblemMsgReqDto reqDto) {
        //您的问题：{targetContentName}还未解决，请及时处理。
        //REMIND_HANDLE_PROBLEM_MSG
        RemindHandleProblemMsgRespDto retData = new RemindHandleProblemMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("REMIND_HANDLE_PROBLEM_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成待签收工作任务消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:22 PM
     **/
    @Trace(operationName = "M2-生成待签收工作任务消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateToBeSignedWorkTaskMsgRespDto generateToBeSignedWorkTaskMsg(GenerateToBeSignedWorkTaskMsgReqDto reqDto) {
        //您有新的工作任务：{targetContentName}，请及时签收。
        //GENERATE_TO_BE_SIGNED_WORK_TASK_MSG
        GenerateToBeSignedWorkTaskMsgRespDto retData = new GenerateToBeSignedWorkTaskMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_TO_BE_SIGNED_WORK_TASK_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成进行中工作任务消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:28 PM
     **/
    @Trace(operationName = "M2-生成进行中工作任务消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateOngoingWorkTaskMsgRespDto generateOngoingWorkTaskMsg(GenerateOngoingWorkTaskMsgReqDto reqDto) {
        //您有新的工作任务：{targetContentName}，请及时处理。
        //GENERATE_ONGOING_WORK_TASK_MSG
        GenerateOngoingWorkTaskMsgRespDto retData = new GenerateOngoingWorkTaskMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_ONGOING_WORK_TASK_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务即将逾期消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:35 PM
     **/
    @Trace(operationName = "M2-生成工作任务即将逾期消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskWillOverdueMsgRespDto workTaskWillOverdueMsg(WorkTaskWillOverdueMsgReqDto reqDto) {
        //您的工作任务：{targetContentName}即将逾期，请及时处理。
        //WORK_TASK_WILL_OVERDUE_MSG
        WorkTaskWillOverdueMsgRespDto retData = new WorkTaskWillOverdueMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_WILL_OVERDUE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务已逾期消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:41 PM
     **/
    @Trace(operationName = "M2-生成工作任务已逾期消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskOverdueMsgRespDto workTaskOverdueMsg(WorkTaskOverdueMsgReqDto reqDto) {
        //您的工作任务：{targetContentName}已逾期，请赶快处理。
        //WORK_TASK_OVERDUE_MSG
        WorkTaskOverdueMsgRespDto retData = new WorkTaskOverdueMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_OVERDUE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成问题消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:47 PM
     **/
    @Trace(operationName = "M2-生成问题消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateProblemMsgRespDto generateProblemMsg(GenerateProblemMsgReqDto reqDto) {
        //您的问题：{targetContentName}即将超时，请及时处理。
        //GENERATE_PROBLEM_MSG
        GenerateProblemMsgRespDto retData = new GenerateProblemMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("GENERATE_PROBLEM_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成问题即将超时消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:34:54 PM
     **/
    @Trace(operationName = "M2-生成问题即将超时消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ProblemWillOvertimeMsgRespDto problemWillOvertimeMsg(ProblemWillOvertimeMsgReqDto reqDto) {
        //您的问题：{targetContentName}即将超时，请及时处理。
        //PROBLEM_WILL_OVERTIME_MSG
        ProblemWillOvertimeMsgRespDto retData = new ProblemWillOvertimeMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("PROBLEM_WILL_OVERTIME_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成问题已超时消息内容
     * desc:undefined
     * gen by moon at 11/8/2023, 3:35:00 PM
     **/
    @Trace(operationName = "M2-生成问题已超时消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ProblemOvertimeMsgRespDto problemOvertimeMsg(ProblemOvertimeMsgReqDto reqDto) {
        //您的问题：{targetContentName}已超时，请赶快处理。
        //PROBLEM_OVERTIME_MSG
        ProblemOvertimeMsgRespDto retData = new ProblemOvertimeMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("PROBLEM_OVERTIME_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务汇报消息内容
     * desc:undefined
     * gen by moon at 11/17/2023, 10:17:29 PM
     **/
    @Trace(operationName = "M2-生成工作任务汇报消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskReportMsgRespDto workTaskReportMsg(WorkTaskReportMsgReqDto reqDto) {
        //WORK_TASK_REPORT_MSG
        //“{targetContentTitleName}”工作任务进度为{comNumField}。
        //{targetContentName}
        WorkTaskReportMsgRespDto retData = new WorkTaskReportMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_REPORT_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentTitleName = "\\{targetContentTitleName}";
            String comNumField = "\\{comNumField}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getTargetContentTitleName() != null && reqDto.getComNumField() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentTitleName, reqDto.getTargetContentTitleName());
                retConent = retConent.replaceAll(comNumField, String.valueOf(reqDto.getComNumField()));
                if (reqDto.getTargetContentName() != null) {
                    retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                }
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成下发公文语义故事
     * desc:undefined
     * gen by moon at 11/17/2023, 10:17:36 PM
     **/
    @Trace(operationName = "M2生成下发公文语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public IssueOffcialDocStoryRespDto issueOffcialDocStory(IssueOffcialDocStoryReqDto reqDto) {
        //ISSUE_OFFCIAL_DOC_STORY
        //{deptShortName} {idCardName}下发公文：《{objectName}》，请注意查收并确认是否有工作安排。
        //{targetContentName}
        IssueOffcialDocStoryRespDto retData = new IssueOffcialDocStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ISSUE_OFFCIAL_DOC_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String deptShortName = "\\{deptShortName}";
            String idCardName = "\\{idCardName}";
            String objectName = "\\{objectName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getDeptShortName() != null && reqDto.getIdCardName() != null && reqDto.getObjectName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName, reqDto.getDeptShortName());
                retConent = retConent.replaceAll(idCardName, reqDto.getIdCardName());
                retConent = retConent.replaceAll(objectName, reqDto.getObjectName());
                if (reqDto.getTargetContentName() != null) {
                    retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                }
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成公文工作任务安排指令故事
     * desc:undefined
     * gen by moon at 11/19/2023, 4:36:55 AM
     **/
    @Trace(operationName = "M2生成公文工作任务安排指令故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ArrangeWorkTaskInstructStoryRespDto arrangeWorkTaskInstructStory(ArrangeWorkTaskInstructStoryReqDto reqDto) {
        //ARRANGE_WORK_TASK_INSTRUCT_STORY
        //{idCardName}下发一份公文《{objectName}》，需要您工作任务安排。请按要求尽快落实，以免耽误工作！
        //{targetContentName}
        ArrangeWorkTaskInstructStoryRespDto retData = new ArrangeWorkTaskInstructStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ARRANGE_WORK_TASK_INSTRUCT_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String objectName = "\\{objectName}";
            if (reqDto != null && reqDto.getIdCardName() != null && reqDto.getObjectName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retConent = retConent.replaceAll(objectName, reqDto.getObjectName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成督办任务安排消息语义故事
     * desc:undefined
     * gen by moon at 11/22/2023, 9:06:32 PM
     **/
    @Trace(operationName = "M2生成督办任务安排消息语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SuperviseTaskArrangeMsgStoryRespDto superviseTaskArrangeMsgStory(SuperviseTaskArrangeMsgStoryReqDto reqDto) {
        //SUPERVISE_TASK_ARRANGE_MSG_STORY
        //请按要求尽快落实《{objectName}》公文的工作任务安排，以免耽误工作！
        SuperviseTaskArrangeMsgStoryRespDto retData = new SuperviseTaskArrangeMsgStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUPERVISE_TASK_ARRANGE_MSG_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectName = "\\{objectName}";
            if (reqDto != null && reqDto.getObjectName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName, reqDto.getObjectName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务xx天后开始文案
     * desc:undefined
     * gen by moon at 11/28/2023, 7:50:25 PM
     **/
    @Trace(operationName = "M2-生成工作任务xx天后开始文案	")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskToStartDaysRespDto workTaskToStartDays(WorkTaskToStartDaysReqDto reqDto) {
        //WORK_TASK_TO_START_DAYS
        //{timeDiffDays}天后开始
        WorkTaskToStartDaysRespDto retData = new WorkTaskToStartDaysRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_TO_START_DAYS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String timeDiffDays = "\\{timeDiffDays}";
            if (reqDto != null && reqDto.getTimeDiffDays() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays, String.valueOf(reqDto.getTimeDiffDays()));
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务提前xx天完成文案
     * desc:undefined
     * gen by moon at 11/28/2023, 7:50:31 PM
     **/
    @Trace(operationName = "M2-生成工作任务提前xx天完成文案	")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskFinishAheadDaysRespDto workTaskFinishAheadDays(WorkTaskFinishAheadDaysReqDto reqDto) {
        //WORK_TASK_FINISH_AHEAD_DAYS
        //提前{timeDiffDays}天完成
        WorkTaskFinishAheadDaysRespDto retData = new WorkTaskFinishAheadDaysRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_FINISH_AHEAD_DAYS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String timeDiffDays = "\\{timeDiffDays}";
            if (reqDto != null && reqDto.getTimeDiffDays() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays, String.valueOf(reqDto.getTimeDiffDays()));
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务逾期xx天完成文案
     * desc:undefined
     * gen by moon at 11/28/2023, 7:50:38 PM
     **/
    @Trace(operationName = "M2-生成工作任务逾期xx天完成文案")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskFinishOverdueDaysRespDto workTaskFinishOverdueDays(WorkTaskFinishOverdueDaysReqDto reqDto) {
        //WORK_TASK_FINISH_OVERDUE_DAYS
        //逾期{timeDiffDays}天完成
        WorkTaskFinishOverdueDaysRespDto retData = new WorkTaskFinishOverdueDaysRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_FINISH_OVERDUE_DAYS");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String timeDiffDays = "\\{timeDiffDays}";
            if (reqDto != null && reqDto.getTimeDiffDays() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays, String.valueOf(reqDto.getTimeDiffDays()));
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2组装指令模板提问内容
     * desc:undefined
     * gen by moon at 12/9/2023, 3:24:43 PM
     **/
    @Trace(operationName = "M2组装指令模板提问内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AssemblyInstructionQusContTempRespDto assemblyInstructionQusContTemp(AssemblyInstructionQusContTempReqDto reqDto) {
        //ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP
        //{content}{instructionTemplate}
        AssemblyInstructionQusContTempRespDto retData = new AssemblyInstructionQusContTempRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String content = "\\{content}";
            String instructionTemplate = "\\{instructionTemplate}";
            if (reqDto != null && reqDto.getContent() != null && reqDto.getInstructionTemplate() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(content, reqDto.getContent());
                retConent = retConent.replaceAll(instructionTemplate, reqDto.getInstructionTemplate());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2组织强提醒提问内容
     * desc:undefined
     * gen by moon at 12/9/2023, 3:24:49 PM
     **/
    @Trace(operationName = "M2组织强提醒提问内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AssemblyStrongReminderQusContTempRespDto assemblyStrongReminderQusContTemp(AssemblyStrongReminderQusContTempReqDto reqDto) {
        //STRONG_REMINDER_QUESTION_CONTENT
        //{strongReminderBasicCopy}{strongReminderContent}
        AssemblyStrongReminderQusContTempRespDto retData = new AssemblyStrongReminderQusContTempRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("STRONG_REMINDER_QUESTION_CONTENT");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String strongReminderBasicCopy = "\\{strongReminderBasicCopy}";
            String strongReminderContent = "\\{strongReminderContent}";
            if (reqDto != null && reqDto.getStrongReminderContent() != null && reqDto.getStrongReminderBasicCopy() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(strongReminderBasicCopy, reqDto.getStrongReminderBasicCopy());
                retConent = retConent.replaceAll(strongReminderContent, reqDto.getStrongReminderContent());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2-生成工作任务失败消息内容
     * desc:undefined
     * gen by moon at 12/9/2023, 9:13:02 PM
     **/
    @Trace(operationName = "M2-生成工作任务失败消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskFailureMsgRespDto workTaskFailureMsg(WorkTaskFailureMsgReqDto reqDto) {
        //WORK_TASK_FAILURE_MSG
        //{idCardName}的工作任务：{targetContentName}已失败。
        WorkTaskFailureMsgRespDto retData = new WorkTaskFailureMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_FAILURE_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String idCardName = "\\{idCardName}";
            String targetContentName = "\\{targetContentName}";
            if (reqDto != null && reqDto.getIdCardName() != null && reqDto.getTargetContentName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName, reqDto.getIdCardName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成下发通知语义故事
     * desc:undefined
     * gen by moon at 12/15/2023, 2:23:38 PM
     **/
    @Trace(operationName = "M2生成下发通知语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public IssueNotificationStoryRespDto issueNotificationStory(IssueNotificationStoryReqDto reqDto) {
        //ISSUE_NOTIFICATION_STORY
        //新通知：《{objectName}》，请注意查收。
        IssueNotificationStoryRespDto retData = new IssueNotificationStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("ISSUE_NOTIFICATION_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectName = "\\{objectName}";
            if (reqDto != null && reqDto.getObjectName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName, reqDto.getObjectName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成工作任务小结语义故事
     * desc:undefined
     * gen by moon at 12/23/2023, 11:06:26 PM
     **/
    @Trace(operationName = "M2生成工作任务小结语义故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public WorkTaskSummarySemanticStoryRespDto workTaskSummarySemanticStory(WorkTaskSummarySemanticStoryReqDto reqDto) {
        //WORK_TASK_SUMMARY_SEMANTIC_STORY
        //{cycleStandardName}{taskName}小结
        WorkTaskSummarySemanticStoryRespDto retData = new WorkTaskSummarySemanticStoryRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("WORK_TASK_SUMMARY_SEMANTIC_STORY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String cycleStandardName = "\\{cycleStandardName}";
            String taskName = "\\{taskName}";
            if (reqDto != null && reqDto.getCycleStandardName() != null && reqDto.getTaskName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retConent = retConent.replaceAll(taskName, reqDto.getTaskName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务问题总结消息内容
     * desc:undefined
     * gen by moon at 12/23/2023, 11:07:11 PM
     **/
    @Trace(operationName = "M2生成汇报任务问题总结消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SubmitReportTaskSummaryMsgRespDto submitReportTaskSummaryMsg(SubmitReportTaskSummaryMsgReqDto reqDto) {
        //SUBMIT_REPORT_TASK_SUMMARY_MSG
        //{objectName}({targetContentName}{cycleStandardName}汇报)
        SubmitReportTaskSummaryMsgRespDto retData = new SubmitReportTaskSummaryMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_SUMMARY_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectName = "\\{objectName}";
            String targetContentName = "\\{targetContentName}";
            String cycleStandardName = "\\{cycleStandardName}";
            if (reqDto != null && reqDto.getObjectName() != null && reqDto.getTargetContentName() != null && reqDto.getCycleStandardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName, reqDto.getObjectName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务解决思路消息内容
     * desc:undefined
     * gen by moon at 12/23/2023, 11:07:19 PM
     **/
    @Trace(operationName = "M2生成汇报任务解决思路消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SubmitReportTaskSolutionIdeaMsgRespDto submitReportTaskSolutionIdeaMsg(SubmitReportTaskSolutionIdeaMsgReqDto reqDto) {
        //SUBMIT_REPORT_TASK_SOLUTION_IDEA_MSG
        //{objectName}({targetContentName}{cycleStandardName}汇报)
        SubmitReportTaskSolutionIdeaMsgRespDto retData = new SubmitReportTaskSolutionIdeaMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_SOLUTION_IDEA_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectName = "\\{objectName}";
            String targetContentName = "\\{targetContentName}";
            String cycleStandardName = "\\{cycleStandardName}";
            if (reqDto != null && reqDto.getObjectName() != null && reqDto.getTargetContentName() != null && reqDto.getCycleStandardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName, reqDto.getObjectName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务改进建议消息内容
     * desc:undefined
     * gen by moon at 12/23/2023, 11:07:25 PM
     **/
    @Trace(operationName = "M2生成汇报任务改进建议消息内容")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SubmitReportTaskImpSugMsgRespDto submitReportTaskImpSugMsg(SubmitReportTaskImpSugMsgReqDto reqDto) {
        //SUBMIT_REPORT_TASK_IMP_SUG_MSG
        //{objectName}({targetContentName}{cycleStandardName}汇报)
        SubmitReportTaskImpSugMsgRespDto retData = new SubmitReportTaskImpSugMsgRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_IMP_SUG_MSG");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String objectName = "\\{objectName}";
            String targetContentName = "\\{targetContentName}";
            String cycleStandardName = "\\{cycleStandardName}";
            if (reqDto != null && reqDto.getObjectName() != null && reqDto.getTargetContentName() != null && reqDto.getCycleStandardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName, reqDto.getObjectName());
                retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成汇报任务工作总结协同内容文案
     * desc:undefined
     * gen by moon at 12/24/2023, 6:14:10 PM
     **/
    @Trace(operationName = "M2生成汇报任务工作总结协同内容文案")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public SubmitReportTaskWorkSummaryTextRespDto submitReportTaskWorkSummaryText(SubmitReportTaskWorkSummaryTextReqDto reqDto) {
        //SUBMIT_REPORT_TASK_WORK_SUMMARY_TEXT
        //{targetContentName}{cycleStandardName}汇报
        SubmitReportTaskWorkSummaryTextRespDto retData = new SubmitReportTaskWorkSummaryTextRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_WORK_SUMMARY_TEXT");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if (detailRes != null && detailRes.getTemplateEngineTemplate() != null) {
            String targetContentName = "\\{targetContentName}";
            String cycleStandardName = "\\{cycleStandardName}";
            if (reqDto != null && reqDto.getTargetContentName() != null && reqDto.getCycleStandardName() != null) {
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName, reqDto.getTargetContentName());
                retConent = retConent.replaceAll(cycleStandardName, reqDto.getCycleStandardName());
                retData.setObjectName(retConent);
            }

            if (bRetFlag) {
                return retData;
            }

        }
        return retData;
    }

    /**
     * code:receptionService
     * name:M2接收字段
     * desc:undefined
     * gen by moon at 12/29/2023, 8:49:42 PM
     **/
    @Trace(operationName = "M2接收字段")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementSmartSessionReceiveFieldInputRespDto implementSmartSessionReceiveFieldInput(ImplementSmartSessionReceiveFieldInputReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementSmartSessionReceiveFieldInputRespDto.class);
    }

    /**
     * code:generateSemanticInstance
     * name:M2生成语义实例故事
     * desc:undefined
     * gen by moon at 12/29/2023, 8:50:47 PM
     **/
    @Trace(operationName = "M2生成语义实例故事")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateSemanticInstanceStoryRespDto generateSemanticInstanceStory(GenerateSemanticInstanceStoryReqDto reqDto) {
        GenerateSemanticInstanceStoryRespDto retData = new GenerateSemanticInstanceStoryRespDto();
        retData.setObjectName(reqDto.getTemplateEngineTemplate());
        for (FieldsNameAndValueToOneDatasDto one : reqDto.getFieldsNameAndValueToOneDatasList()) {
            String fileName = "\\{" + one.getFieldName() + "}";
            retData.setObjectName(retData.getObjectName().replaceAll(fileName, one.getFieldValue()));
        }
        return retData;
    }
    //手工接入方法
}
